# uncompyle6 version 3.2.3
# Python bytecode 3.6 (3379)
# Decompiled from: Python 3.6.8 |Anaconda custom (64-bit)| (default, Feb 21 2019, 18:30:04) [MSC v.1916 64 bit (AMD64)]
# Embedded file name: site-packages\sqlalchemy\orm\evaluator.py
import operator
from ..sql import operators
from .. import inspect
from .. import util


class UnevaluatableError(Exception):
    pass


_straight_ops = set(
    (
        getattr(operators, op)
        for op in (
            "add",
            "mul",
            "sub",
            "div",
            "mod",
            "truediv",
            "lt",
            "le",
            "ne",
            "gt",
            "ge",
            "eq",
        )
    )
)
_notimplemented_ops = set(
    (
        getattr(operators, op)
        for op in (
            "like_op",
            "notlike_op",
            "ilike_op",
            "notilike_op",
            "between_op",
            "in_op",
            "notin_op",
            "endswith_op",
            "concat_op",
        )
    )
)


class EvaluatorCompiler(object):
    def __init__(self, target_cls=None):
        self.target_cls = target_cls

    def process(self, clause):
        meth = getattr(self, "visit_%s" % clause.__visit_name__, None)
        if not meth:
            raise UnevaluatableError("Cannot evaluate %s" % type(clause).__name__)
        return meth(clause)

    def visit_grouping(self, clause):
        return self.process(clause.element)

    def visit_null(self, clause):
        return lambda obj: None

    def visit_false(self, clause):
        return lambda obj: False

    def visit_true(self, clause):
        return lambda obj: True

    def visit_column(self, clause):
        if "parentmapper" in clause._annotations:
            parentmapper = clause._annotations["parentmapper"]
            if self.target_cls:
                if not issubclass(self.target_cls, parentmapper.class_):
                    raise UnevaluatableError(
                        "Can't evaluate criteria against alternate class %s"
                        % parentmapper.class_
                    )
            key = parentmapper._columntoproperty[clause].key
        else:
            key = clause.key
            if self.target_cls:
                if key in inspect(self.target_cls).column_attrs:
                    util.warn(
                        "Evaluating non-mapped column expression '%s' onto ORM instances; this is a deprecated use case.  Please make use of the actual mapped columns in ORM-evaluated UPDATE / DELETE expressions."
                        % clause
                    )
                raise UnevaluatableError("Cannot evaluate column: %s" % clause)
        get_corresponding_attr = operator.attrgetter(key)
        return lambda obj: get_corresponding_attr(obj)

    def visit_clauselist(self, clause):
        evaluators = list(map(self.process, clause.clauses))
        if clause.operator is operators.or_:

            def evaluate(obj):
                has_null = False
                for sub_evaluate in evaluators:
                    value = sub_evaluate(obj)
                    if value:
                        return True
                    has_null = has_null or value is None

                if has_null:
                    return
                else:
                    return False

        else:
            if clause.operator is operators.and_:

                def evaluate(obj):
                    for sub_evaluate in evaluators:
                        value = sub_evaluate(obj)
                        if not value:
                            if value is None:
                                return
                            return False

                    return True

            else:
                raise UnevaluatableError(
                    "Cannot evaluate clauselist with operator %s" % clause.operator
                )
            return evaluate

    def visit_binary(self, clause):
        eval_left, eval_right = list(map(self.process, [clause.left, clause.right]))
        operator = clause.operator
        if operator is operators.is_:

            def evaluate(obj):
                return eval_left(obj) == eval_right(obj)

        else:
            if operator is operators.isnot:

                def evaluate(obj):
                    return eval_left(obj) != eval_right(obj)

            else:
                if operator in _straight_ops:

                    def evaluate(obj):
                        left_val = eval_left(obj)
                        right_val = eval_right(obj)
                        if left_val is None or right_val is None:
                            return
                        else:
                            return operator(eval_left(obj), eval_right(obj))

                else:
                    raise UnevaluatableError(
                        "Cannot evaluate %s with operator %s"
                        % (type(clause).__name__, clause.operator)
                    )
                return evaluate

    def visit_unary(self, clause):
        eval_inner = self.process(clause.element)
        if clause.operator is operators.inv:

            def evaluate(obj):
                value = eval_inner(obj)
                if value is None:
                    return
                else:
                    return not value

            return evaluate
        raise UnevaluatableError(
            "Cannot evaluate %s with operator %s"
            % (type(clause).__name__, clause.operator)
        )

    def visit_bindparam(self, clause):
        if clause.callable:
            val = clause.callable()
        else:
            val = clause.value
        return lambda obj: val
